SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
Rust

Rust static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your RUST code

  • All rules 85
  • Bug60
  • Code Smell25

  • Quick Fix 4
 
Tags
    Impact
      Clean code attribute
        1. Match expression conditions should not have boolean type

           Code Smell
        2. Pointer arithmetic should not be performed on zero-sized types

           Code Smell
        3. Shared code in all branches should be extracted

           Code Smell
        4. Inline vector literals should be preferred to chains of insertions

           Code Smell
        5. Mathematical constants should not be hardcoded

           Code Smell
        6. "std::ptr::null" should be used to denote the null pointer

           Code Smell
        7. Redundant casts should be avoided

           Code Smell
        8. Cognitive Complexity of functions should not be too high

           Code Smell
        9. Array elements should be separated by commas

           Code Smell
        10. Field init shorthand should be used

           Code Smell
        11. Boolean expressions should not be gratuitous

           Code Smell
        12. Invisible Unicode characters should not be used

           Code Smell
        13. Unnecessary bit operations should not be performed

           Code Smell
        14. Rust source files should not have syntax errors

           Code Smell
        15. Wildcard imports should not be used

           Code Smell
        16. Unnecessary mathematical comparisons should not be made

           Code Smell
        17. Erasing mathematical operations should not be performed

           Code Smell
        18. Underscores should be used to make large numbers readable

           Code Smell
        19. "to_string()" should never be called on a String value

           Code Smell
        20. Closures should be replaced with function pointers

           Code Smell
        21. Local variables should not be declared and then immediately returned

           Code Smell
        22. "if ... else if" constructs should end with "else" clauses

           Code Smell
        23. Empty statements should be removed

           Code Smell
        24. Functions should not have too many parameters

           Code Smell
        25. Standard outputs should not be used directly to log anything

           Code Smell

        Redundant casts should be avoided

        intentionality - clear
        maintainability
        Code Smell
        Quick FixIDE quick fixes available with SonarQube for IDE
        • redundant
        • clippy

        Why is this an issue?

        More Info

        In Rust, type casting is a mechanism used to convert a value from one type to another. This is often necessary when working with different types that are compatible but not the same. However, unnecessary casts can occur when the type conversion is redundant because the compiler already knows the type based on the context or explicit type declarations.

        Unnecessary casts should be avoided in Rust code as they add unnecessary complexity, clutter the code, and can lead to confusion. They also make the code less idiomatic and harder to read.

        fn get_length(value: &str) -> usize {
            let length = value.len() as usize; // Noncompliant: 'value.len()' already returns a 'usize'
            length
        }
        

        Remove all unnecessary casts based on the contextual typing information, as inferred by the Rust compiler.

        fn get_length(value: &str) -> usize {
            let length = value.len();
            length
        }
        
          Available In:
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use